dnl Process this file with autoconf to produce a configure script.
AC_INIT(gimprc.in)

#
# Making releases:
#   GIMP_MICRO_VERSION += 1;
#   GIMP_INTERFACE_AGE += 1;
#   GIMP_BINARY_AGE += 1;
# if any functions have been added, set GIMP_INTERFACE_AGE to 0.
# if backwards compatibility has been broken,
# set GIMP_BINARY_AGE and GIMP_INTERFACE_AGE to 0.
#
GIMP_MAJOR_VERSION=1
GIMP_MINOR_VERSION=2
GIMP_MICRO_VERSION=4
GIMP_INTERFACE_AGE=4
GIMP_BINARY_AGE=4
GIMP_VERSION=$GIMP_MAJOR_VERSION.$GIMP_MINOR_VERSION.$GIMP_MICRO_VERSION

dnl libtool versioning
LT_RELEASE=$GIMP_MAJOR_VERSION.$GIMP_MINOR_VERSION
LT_CURRENT=`expr $GIMP_MICRO_VERSION - $GIMP_INTERFACE_AGE`
LT_REVISION=$GIMP_INTERFACE_AGE
LT_AGE=`expr $GIMP_BINARY_AGE - $GIMP_INTERFACE_AGE`
LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`

VERSION=$GIMP_VERSION
PACKAGE=gimp

AM_INIT_AUTOMAKE($PACKAGE, $VERSION, no-define)

AM_CONFIG_HEADER(config.h)

dnl Initialize libtool
AC_PROG_CC
AC_LIBTOOL_WIN32_DLL
AM_PROG_LIBTOOL

dnl Initialize maintainer mode
AM_MAINTAINER_MODE

AC_CANONICAL_HOST

AC_MSG_CHECKING([for some Win32 platform])
case "$host" in
  *-*-mingw*|*-*-cygwin*)
    platform_win32=yes
    ;;
  *)
    platform_win32=no
    ;;
esac
AC_MSG_RESULT([$platform_win32])
AM_CONDITIONAL(PLATFORM_WIN32, test "$platform_win32" = "yes")

AC_MSG_CHECKING([for native Win32])
case "$host" in
  *-*-mingw*)
    os_win32=yes
    PATHSEP=';'
    ;;
  *)
    os_win32=no
    PATHSEP=':'
    ;;
esac
AC_MSG_RESULT([$os_win32])
AC_SUBST(PATHSEP)
AM_CONDITIONAL(OS_WIN32, test "$os_win32" = "yes")

if test "$os_win32" = "yes"; then
  AC_CHECK_PROG(ms_librarian, lib.exe, yes, no)
fi
AM_CONDITIONAL(MS_LIB_AVAILABLE, test x$ms_librarian = xyes)

dnl Checks for programs.
AC_ISC_POSIX
AM_PROG_CC_STDC
AC_PROG_INSTALL
AC_PROG_LN_S
AC_PROG_MAKE_SET
AC_PROG_CPP

AC_ARG_ENABLE(debug, [  --enable-debug          turn on debugging [default=no]],
if eval "test x$enable_debug = xyes"; then
  DEBUGFLAG="-g"
fi)

ACLOCAL="$ACLOCAL $ACLOCAL_FLAGS"

dnl Why the heck isn't there already a macro for this?

dnl AC_ARG_WITH(gnu-make, [  --with-gnu-make         assume 'make' understands gnu extensions],
dnl,
dnl if $ac_make -v 2>/dev/null | grep 'GNU Make' >/dev/null; then
dnl   with_gnu_make=yes
dnl fi)
dnl
dnl AC_ARG_WITH(gcg, [  --with-gcg              build 'gcg' code generation tool],
dnl,
dnl with_gcg=$enable_maintainer_mode)
dnl
dnl if test "x$with_gcg" = xyes; then
dnl   AC_CONFIG_SUBDIRS(tools/gcg)
dnl fi
dnl
dnl AC_ARG_ENABLE(gcg-deps, [  --enable-gcg-deps       turn on dynamic gcg dependency tracking (need gcc and gnu make)],
dnl ,
dnl if eval "test x$GCC$with_gnu_make$with_gcg = xyesyesyes"; then
dnl   enable_gcg_deps=yes
dnl fi)
dnl
dnl AM_CONDITIONAL(WITH_GCG, test x$with_gcg = xyes)
dnl AM_CONDITIONAL(WITH_GNU_MAKE, test x$with_gnu_make = xyes)
dnl AM_CONDITIONAL(ENABLE_GCG_DEPS, test x$enable_gcg_deps = xyes)

AC_ARG_ENABLE(ansi, [  --enable-ansi           turn on strict ansi [default=no]],
		    , enable_ansi=no)

dnl Possibly change default gimpdir from .gimp
gimpdir=.$PACKAGE-$GIMP_MAJOR_VERSION.$GIMP_MINOR_VERSION
AC_ARG_ENABLE(gimpdir, [  --enable-gimpdir=DIR    change default gimpdir from .gimp-1.2 to DIR],
if eval "test x$enable_gimpdir != x"; then
  if eval "test x$enable_gimpdir != xyes"; then
    gimpdir=$enable_gimpdir
  fi
fi)

if test -n "$DEBUGFLAG"; then
  CFLAGS="$DEBUGFLAG $CFLAGS"
fi


dnl i18n stuff
ALL_LINGUAS="ca cs da de el en_GB es fi fr ga gl hu hr it ja ko lt nl nn no pl pt pt_BR ro ru sk sl sv tr uk zh_CN zh_TW"
if test x$os_win32 = xyes; then
  AM_GLIB_GNU_GETTEXT
  dnl Awful hacks so AC_OUTPUT doesn't complain...
  dnl and we don't use the "normal" gettextize stuff anyway
  mkdir intl
  touch intl/Makefile.in
  touch po/Makefile.in.in
  touch po-libgimp/Makefile.in.in
  touch plug-ins/perl/po/Makefile.in.in
  touch po-plug-ins/Makefile.in.in
  touch po-script-fu/Makefile.in.in
else
  AM_GNU_GETTEXT
fi

dnl Check for GTK+
if test x$os_win32 = xyes; then
  dnl On Win32, use the gtk-1-3-win32-production branch of GTK+
  dnl which really is like GTK+ 1.2.7 or thereabouts, API-wise.
  PKG_CHECK_MODULES(GTK, gtk+-1.3-win32-production >= 1.3.0)
  dnl and fresh GLib.
  PKG_CHECK_MODULES(GLIB, glib-2.0 >= 1.3.9)
else
  AM_PATH_GTK(1.2.8,,
    AC_MSG_ERROR(Test for GTK failed. See the file 'INSTALL' for help.))

  dnl Quick hack to deny non GTK 1.2
  if (expr $gtk_config_major_version \> 1) > /dev/null; then
    AC_MSG_ERROR(GIMP does not work with versions of GTK > 1.2)
  fi
  if (expr $gtk_config_minor_version \> 2) > /dev/null; then
    AC_MSG_ERROR(GIMP does not work with versions of GTK > 1.2)
  fi
fi

changequote(,)dnl

if test x$os_win32 != xyes; then
  dnl Evil stuff to extract GLIB stuff from gtk-config output
  dnl (we want to make sure it matches with the gtk we're using)
  GTK_TEMP_CFLAGS=`echo $GTK_CFLAGS | sed 's/^\(-I[^ ]*\).*$/\1/'`
  if echo $GTK_TEMP_CFLAGS | grep 'glib/include$' > /dev/null; then
    GTK_TEMP_CFLAGS=$GTK_CFLAGS
  else
    GTK_TEMP_CFLAGS=`echo $GTK_CFLAGS | sed 's/^-I[^ ]* \(.*\)$/\1/'`
  fi
  GLIB_CFLAGS=`echo $GTK_TEMP_CFLAGS | sed 's/^\(-I[^ ]*glib[^ ]*  *-I[^ ]*\).*/\1/'`

  GLIB_LDFLAGS=`echo $GTK_LIBS | sed -e 's/^.*-lgdk[^ ]* *\(-L[^ ]*\).*$/\1/' -e 's/^.* -lgdk[^ ]* .*$//'`
  if test -z "$GLIB_LDFLAGS" ; then
    GLIB_LDFLAGS=`echo $GTK_LIBS | sed 's/^ *\(-L[^ ]*\) .*$/\1/'`
  fi 
  GLIB_LIBS="$GLIB_LDFLAGS `echo $GTK_LIBS | sed 's/^.*\(-lglib[^ ]*\).*$/\1/'`"
fi

if eval "test x$GCC = xyes"; then
  case " $CFLAGS " in
  *[\ \	]-Wall[\ \	]*) ;;
  *) CFLAGS="$CFLAGS -Wall" ;;
  esac

  if test "x$enable_ansi" = "xyes"; then
    case " $CFLAGS " in
    *[\ \	]-ansi[\ \	]*) ;;
    *) CFLAGS="$CFLAGS -ansi" ;;
    esac

    case " $CFLAGS " in
    *[\ \	]-pedantic[\ \	]*) ;;
    *) CFLAGS="$CFLAGS -pedantic" ;;
    esac
  fi
fi

changequote([,])dnl

dnl Ensure MSVC-compatible struct packing convention is used when
dnl compiling for Win32 with gcc. GTK+ uses this convention, so we must, too.
dnl What flag to depends on gcc version: gcc3 uses "-mms-bitfields", while
dnl gcc2 uses "-fnative-struct".
if test x"$os_win32" = xyes; then
  if test x"$GCC" = xyes; then
    msnative_struct=''
    AC_MSG_CHECKING([how to get MSVC-compatible struct packing])
    if test -z "$ac_cv_prog_CC"; then
      our_gcc="$CC"
    else
      our_gcc="$ac_cv_prog_CC"
    fi
    case `$our_gcc --version | sed -e 's,\..*,.,' -e q` in
      2.)
	if $our_gcc -v --help 2>/dev/null | grep fnative-struct >/dev/null; then
	  msnative_struct='-fnative-struct'
	fi
	;;
      *)
	if $our_gcc -v --help 2>/dev/null | grep ms-bitfields >/dev/null; then
	  msnative_struct='-mms-bitfields'
	fi
	;;
    esac
    if test x"$msnative_struct" = x ; then
      AC_MSG_RESULT([no way])
      AC_MSG_WARN([produced libraries will be incompatible with prebuilt GTK+ DLLs])
    else
      CFLAGS="$CFLAGS $msnative_struct"
      AC_MSG_RESULT([${msnative_struct}])
    fi
  fi
fi

AC_CHECK_HEADERS(math.h ieeefp.h)

dnl DU4 native cc currently needs -std1 for ANSI mode (instead of K&R)
AC_MSG_CHECKING([for extra flags to get ANSI library prototypes])
gimp_save_LIBS=$LIBS
LIBS="$LIBS -lm"
AC_TRY_RUN([#include <math.h>
             int main (void) { return (log(1) != log(1.)); }],
  AC_MSG_RESULT(none needed),
  gimp_save_CFLAGS=$CFLAGS
  CFLAGS="$CFLAGS -std1"
  AC_TRY_RUN([#include <math.h>
               int main (void) { return (log(1) != log(1.)); }],
    AC_MSG_RESULT(-std1),
    AC_MSG_RESULT()
    CFLAGS=$gimp_save_CFLAGS
    AC_MSG_WARN([No ANSI prototypes found in library. (-std1 didn't work.)]),
    AC_MSG_RESULT),
  AC_MSG_RESULT())

dnl Check for finite or isfinite
AC_CHECK_FUNCS(finite, , [
  AC_MSG_CHECKING(for finite in <math.h>)
  AC_TRY_LINK([#include <math.h>], [double f = 0.0; finite (f)], [
    AC_DEFINE(HAVE_FINITE)
    AC_MSG_RESULT(yes)], [
    AC_MSG_RESULT(no)
    AC_MSG_CHECKING(for isfinite in <math.h>)
    AC_TRY_LINK([#include <math.h>], [float f = 0.0; isfinite(f)], [
      AC_DEFINE(HAVE_ISFINITE)
      AC_MSG_RESULT(yes)], AC_MSG_RESULT(no))])])

LIBS=$gimp_save_LIBS

dnl NeXTStep cc seems to need this
AC_MSG_CHECKING([for extra flags for POSIX compliance])
AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
  AC_MSG_RESULT(none needed),
  gimp_save_CFLAGS=$CFLAGS
  CFLAGS="$CFLAGS -posix"
  AC_TRY_COMPILE([#include <dirent.h>], [DIR *dir;],
    AC_MSG_RESULT(-posix),
    AC_MSG_RESULT()
    CFLAGS=$gimp_save_CFLAGS
    AC_MSG_WARN([Could not determine POSIX flag. (-posix didn't work.)])))

gimp_save_CPPFLAGS="$CPPFLAGS"
gimp_save_LDFLAGS="$LDFLAGS"
gimp_save_LIBS="$LIBS"

CPPFLAGS="$CPPFLAGS $GTK_CFLAGS"
LDFLAGS="$LDFLAGS `echo $GTK_LIBS | sed 's/\(.*\)\(-lgtk.*\)/\1/'`"
LIBS="$LIBS $GTK_LIBS"

dnl Test for Xmu
  if test -z "$LIBXMU"; then
    AC_CHECK_LIB(Xmu, XmuClientWindow,
      [AC_CHECK_HEADER(X11/Xmu/WinUtil.h,
	WEBBROWSER="webbrowser"; GIMP_REMOTE="gimp-remote-1.2"; LIBXMU='-lXmu -lXt -lSM -lICE',
	[AC_MSG_WARN(*** webbrowser plug-in and gimp-remote will not be built (XMU header file not found) ***)])],
	[AC_CHECK_LIB(Xmu, XmuUpdateMapHints,
	  [AC_CHECK_HEADER(X11/Xmu/WinUtil.h,
	    WEBBROWSER="webbrowser"; GIMP_REMOTE="gimp-remote-1.2"; LIBXMU='-lXmu -lXt',
	    [AC_MSG_WARN(*** webbrowser plug-in and gimp-remote will not be built (XMU header file not found) ***)])],
	[AC_MSG_WARN(*** webbrowser plug-in and gimp-remote will not be built (XMU library not found) ***)], -lXt)], -lXt -lSM -lICE)
  fi

dnl set WEBBROWSER on Win32
if test x$os_win32 = xyes; then
  WEBBROWSER=webbrowser
fi

dnl Test for libaa
  if test -z "$LIBAA"; then
    AC_CHECK_LIB(aa, aa_printf,
      [AC_CHECK_HEADER(aalib.h,
	AA='aa'; LIBAA='-laa',
	[AC_MSG_WARN(*** AA plug-in will not be built (AA header file not found) ***)])],
      [AC_MSG_WARN(*** AA plug-in will not be built (AA library not found) ***)])
  fi

dnl Test for libtiff
AC_ARG_WITH(libtiff,  [  --without-libtiff       build without TIFF support])
  if test x$with_libtiff != xno && test -z "$LIBTIFF"; then
    AC_CHECK_LIB(tiff, TIFFReadScanline,
      [AC_CHECK_HEADER(tiffio.h,
	TIFF='tiff'$EXEEXT; LIBTIFF='-ltiff',
	[AC_MSG_WARN(*** TIFF plug-in will not be built (TIFF header files not found) ***)])],
      [AC_CHECK_LIB(tiff, TIFFWriteScanline,
	[AC_CHECK_HEADER(tiffio.h,
          TIFF='tiff'; LIBTIFF='-ltiff -ljpeg -lz',
	  [AC_MSG_WARN(*** TIFF plug-in will not be built (TIFF header files not found) ***)])],
	[AC_CHECK_LIB(tiff34, TIFFFlushData,
	  [AC_CHECK_HEADER(tiffio.h,
            TIFF='tiff'; LIBTIFF='-ltiff34 -ljpeg -lz',
	    [AC_MSG_WARN(*** TIFF plug-in will not be built (TIFF header files not found) ***)])],
        [AC_MSG_WARN(*** TIFF plug-in will not be built (TIFF library not found) ***)], -ljpeg -lz -lm)], -ljpeg -lz -lm)], -lm)
  fi

if test x$with_libtiff != xno && test -z "$LIBTIFF"; then
  AC_MSG_ERROR([
*** Checks for TIFF libary failed. You can build without it by passing 
*** --without-libtiff to configure but you won't be able to use TIFFs then.])
fi

dnl Test for libjpeg
AC_ARG_WITH(libjpeg, [  --without-libjpeg       build without JPEG support])
  if test x$with_libjpeg != xno && test -z "$LIBJPEG"; then
    AC_CHECK_LIB(jpeg, jpeg_destroy_decompress,
      jpeg_ok=yes,
      jpeg_ok=no
      [AC_MSG_WARN(*** JPEG plug-in will not be built (JPEG library not found) ***)]
      [AC_MSG_WARN(*** XJT plug-in will not be built (JPEG library not found) ***)])
    if test "$jpeg_ok" = yes; then
      AC_MSG_CHECKING([for jpeglib.h])
      AC_TRY_CPP(
[#include <stdio.h>
#undef HAVE_STDDEF_H
#undef HAVE_STDLIB_H
#undef PACKAGE
#undef VERSION
#include <jpeglib.h>],
	jpeg_ok=yes,
	jpeg_ok=no)
      AC_MSG_RESULT($jpeg_ok)
      if test "$jpeg_ok" = yes; then
	JPEG='jpeg'$EXEEXT; LIBJPEG='-ljpeg'
	if test x$os_win32 != xyes; then
	  XJT='xjt';
        fi
	AC_CHECK_LIB(jpeg, jpeg_simple_progression,	
	  AC_DEFINE(HAVE_PROGRESSIVE_JPEG),
	  AC_MSG_WARN(JPEG library does not support progressive saving.))
      else
	AC_MSG_WARN(*** JPEG plug-in will not be built (JPEG header file not found) ***)
        AC_MSG_WARN(*** XJT plug-in will not be built (JPEG header file not found) ***)
      fi
    fi
  fi

if test x$with_libjpeg != xno && test -z "$LIBJPEG"; then
  AC_MSG_ERROR([
*** Checks for JPEG library failed. You can build without it by passing 
*** --without-libjpeg to configure but you won't be able to use JPEGs then.])
fi

dnl Test for libz
  if test -z "$LIBZ"; then
    AC_CHECK_LIB(z, gzsetparams,
      [AC_CHECK_HEADER(zlib.h,
	PSP='psp'; LIBZ='-lz',
	[AC_MSG_WARN(*** PSP and PNG plug-ins will not be built (ZLIB header files not found) ***)])],
      [AC_MSG_WARN(*** PSP and PNG plug-ins will not be built (ZLIB library not found) ***)])
  fi


dnl Test for libpng
AC_ARG_WITH(png, [  --without-libpng        build without PNG support])
  if test x$with_libpng != xno && test -z "$LIBPNG" && test -n "$LIBZ"; then
    AC_CHECK_LIB(png, png_read_info,
      [AC_CHECK_HEADER(png.h,
	png_ok=yes,
	png_ok=no)],
      [AC_MSG_WARN(*** PNG plug-in will not be built (PNG library not found) ***)], -lz -lm)
    if test "$png_ok" = yes; then
      AC_MSG_CHECKING([for png_structp in png.h])
      AC_TRY_COMPILE([#include <png.h>],
        [png_structp pp; png_infop info; png_colorp cmap; png_create_read_struct;],
        png_ok=yes,
        png_ok=no)
      AC_MSG_RESULT($png_ok)
      if test "$png_ok" = yes; then
        PNG='png'$EXEEXT; LIBPNG="-lpng $LIBZ"
      else
        AC_MSG_WARN(*** PNG plug-in will not be built (PNG library is too old) ***)
      fi
    else
      AC_MSG_WARN(*** PNG plug-in will not be built (PNG header file not found) ***)
    fi
  fi

if test x$with_libpng != xno && test -z "$LIBPNG"; then
  AC_MSG_ERROR([
*** Checks for PNG library failed. You can build without it by passing 
*** --without-libpng to configure but you won't be able to use PNGs then.])
fi

dnl Test for libmpeg
  if test -z "$LIBMPEG"; then
    AC_CHECK_LIB(mpeg, GetMPEGFrame,
      [AC_CHECK_HEADER(mpeg.h,
	MPEG='mpeg'$EXEEXT; LIBMPEG='-lmpeg'; GAP_DECODE_MPEG='gap_decode_mpeg',
	[AC_MSG_WARN(*** MPEG plug-in will not be built (MPEG header file not found) ***)])],
      [AC_MSG_WARN(*** MPEG plug-in will not be built (MPEG library not found) ***)])
  fi

dnl Test for libXpm
  if test -z "$LIBXPM"; then
    AC_CHECK_LIB(Xpm, XpmReadFileToXpmImage,
      [AC_CHECK_HEADER(X11/xpm.h,
	XPM='xpm'$EXEEXT; LIBXPM='-lXpm',
	[AC_MSG_WARN(*** XPM plug-in will not be built (XPM header file not found) ***)])],
      [AC_MSG_WARN(*** XPM plug-in will not be built (XPM library not found) ***)], $X_LIBS)
  fi

dnl Check for shared memory

dnl MacOS X has broken SysV shm
case "$host_os" in
  darwin* | rhapsody* | machten*)
    # We can put something else here when something that works is implemented
    shmdefault=none
    ;;
  *)
    shmdefault=sysv
    ;;
esac
                                                                                
shmtype=auto
AC_ARG_WITH(shm, [  --with-shm=none/sysv/auto     shared memory transport type [default=auto]], shmtype=$with_shm)
                                                                                
case $shmtype in
  none|sysv) ;;
  auto) shmtype=$shmdefault ;;
  *) AC_MSG_ERROR([Invalid shared memory transport type: use none, sysv, or auto.]);;
esac
                                                                                
if test "x$shmtype" = "xsysv"; then
  AC_CHECK_HEADER(sys/ipc.h, AC_DEFINE(HAVE_IPC_H), no_sys_ipc=yes)
  AC_CHECK_HEADER(sys/shm.h, AC_DEFINE(HAVE_SHM_H), no_sys_shm=yes)
  if test "$ac_cv_header_sys_shm_h" = "yes"; then
    AC_MSG_CHECKING(whether shmctl IPC_RMID allowes subsequent attaches)
    AC_TRY_RUN([
	#include <sys/types.h>
	#include <sys/ipc.h>
	#include <sys/shm.h>
	int main()
	{
	  int id;
	  char *shmaddr;
	id = shmget (IPC_PRIVATE, 4, IPC_CREAT | 0600);
	if (id == -1)
	  exit (2);
	  shmaddr = shmat (id, 0, 0);
	  shmctl (id, IPC_RMID, 0);
	  if ((char*) shmat (id, 0, 0) == (char*) -1)
	  {
	    shmdt (shmaddr);
	    exit (1);
	  }
	  shmdt (shmaddr);
	  shmdt (shmaddr);
	  exit (0);
	}
      ],
      AC_DEFINE(IPC_RMID_DEFERRED_RELEASE)
        AC_MSG_RESULT(yes),
      AC_MSG_RESULT(no),
      AC_MSG_RESULT(assuming no))
  fi
fi

AC_HEADER_DIRENT
AC_HEADER_STDC
AC_HEADER_SYS_WAIT
AC_HEADER_TIME

AC_CHECK_HEADER(sys/param.h, AC_DEFINE(HAVE_SYS_PARAM_H))
AC_CHECK_HEADER(sys/time.h, AC_DEFINE(HAVE_SYS_TIME_H))
AC_CHECK_HEADER(sys/times.h, AC_DEFINE(HAVE_SYS_TIMES_H))
AC_CHECK_HEADER(sys/wait.h, AC_DEFINE(HAVE_SYS_WAIT_H))
AC_CHECK_HEADER(unistd.h, AC_DEFINE(HAVE_UNISTD_H))
AC_CHECK_HEADER(winsock.h, AC_DEFINE(HAVE_WINSOCK_H))

AC_TYPE_PID_T
AC_TYPE_SIGNAL
AC_FUNC_VPRINTF

AC_FUNC_ALLOCA

dnl Check for sys/select.h

AC_MSG_CHECKING([fd_set and sys/select])
AC_TRY_COMPILE([#include <sys/types.h>],
        [fd_set readMask, writeMask;], gimp_ok=yes, gimp_ok=no)
if test $gimp_ok = no; then
    AC_HEADER_EGREP(fd_mask, sys/select.h, gimp_ok=yes)
    if test $gimp_ok = yes; then
        AC_DEFINE(HAVE_SYS_SELECT_H)
    fi
fi
AC_MSG_RESULT($gimp_ok)
if test $gimp_ok = no; then
    AC_DEFINE(NO_FD_SET)
fi

if test x$os_win32 = xyes; then
  dnl GIMP_WIN32_RAND_FUNC and GIMP_WIN32_SRAND_FUNC are macros in
  dnl libgimp/gimpmath.h inside #ifdef G_OS_WIN32
  AC_DEFINE(RAND_FUNC, GIMP_WIN32_RAND_FUNC)
  AC_DEFINE(SRAND_FUNC, GIMP_WIN32_SRAND_FUNC)
else
dnl Check for random number functions
LIBUCB=""
AC_CHECK_FUNC(random, [
  AC_DEFINE(RAND_FUNC, random)
  AC_DEFINE(SRAND_FUNC, srandom)],
  [AC_CHECK_LIB(ucb, random, [
    AC_DEFINE(RAND_FUNC, random)
    AC_DEFINE(SRAND_FUNC, srandom)
    LIBUCB='-lucb'],
    [AC_CHECK_FUNC(lrand48,
      [AC_DEFINE(RAND_FUNC, lrand48) AC_DEFINE(SRAND_FUNC, srand48)],
      [AC_DEFINE(RAND_FUNC, rand) AC_DEFINE(SRAND_FUNC, srand)])])])
fi

dnl check for difftime
AC_CHECK_FUNC(difftime, , AC_DEFINE(NO_DIFFTIME))

dnl check for putenv (because %#@&% NeXTStep doesn't have it)
AC_CHECK_FUNC(putenv, AC_DEFINE(HAVE_PUTENV))

dnl check for rint
AC_CHECK_FUNC(rint, AC_DEFINE(HAVE_RINT), [
  AC_CHECK_LIB(m, rint, [
    AC_DEFINE(HAVE_RINT)])])

if test x$os_win32 = xyes; then
  dnl Check for bind_textdomain_codeset, including -lintl if GLib brings it in.
  gimp_save_LIBS=$LIBS
  LIBS="$LIBS $GLIB_LIBS"
  AC_CHECK_FUNCS(bind_textdomain_codeset)
  LIBS=$gimp_save_LIBS

  dnl Include hack for bug #66859 on Win32
  CFLAGS="$CFLAGS -DHACK_FOR_BUG_66859"
fi

dnl check for mmap
AC_CHECK_FUNCS(mmap)

dnl This is for the help browser
AC_PATH_PROG(GNOME_CONFIG,gnome-config,no)
if test "$GNOME_CONFIG" = "no"; then
  dnl Test for standalone GtkXMHTML widget
  HELPBROWSER=
  if test -n "$LIBPNG" && test -n "$LIBJPEG" && test -n "$LIBXPM"; then
    helpbrowser_save_LIBS=$LIBS
    LIBS="$LIBS $LIBPNG $LIBJPEG $LIBXPM"
    AC_CHECK_LIB(gtkxmhtml, gtk_xmhtml_new,
      GTKXMHTML_CFLAGS=$GTK_CFLAGS
      GTKXMHTML_LIBS="-lgtkxmhtml $LIBPNG $LIBJPEG $LIBXPM $GTK_LIBS"
      HELPBROWSER=helpbrowser,
      AC_MSG_WARN(*** Help browser plug-in will not be built (GtkXMHTML library not found) ***))
    LIBS=$helpbrowser_save_LIBS
  else
    AC_MSG_WARN(*** Help browser plug-in will not be built (PNG, JPEG or XPM libraries not found) ***)
  fi
else
  GTKXMHTML_CFLAGS=`$GNOME_CONFIG --cflags gnomeui`
  GTKXMHTML_LIBS=`$GNOME_CONFIG --libs gtkxmhtml`
  HELPBROWSER=helpbrowser
fi

dnl Sanity check to make sure the headers are there too and that gnome-config
dnl didn't lie to us
if test -n "$HELPBROWSER"; then
  CPPFLAGS="$CPPFLAGS $GTKXMHTML_CFLAGS"
  LDFLAGS="$LDFLAGS `echo $GTKXMHTML_LIBS | sed 's/\(.*\)\(-lgtkxmhtml.*\)/\1/'`"
  LIBS="$LIBS $GTKXMHTML_LIBS"

  AC_MSG_CHECKING([to see if we can build with GtkXMHTML])
  AC_TRY_LINK([#include <gtk-xmhtml/gtk-xmhtml.h>], [return 0;],
    gtkxmhtml_ok=yes, gtkxmhtml_ok=no)
  AC_MSG_RESULT($gtkxmhtml_ok)

  if test "$gtkxmhtml_ok" = no; then
    AC_MSG_WARN(*** Help browser plug-in will not be built (GtkXMHTML setup busted) ***)
    HELPBROWSER=
  fi
fi

CPPFLAGS="$gimp_save_CPPFLAGS"
LDFLAGS="$gimp_save_LDFLAGS"
LIBS="$gimp_save_LIBS"

dnl Threads
dnl AC_ARG_WITH(threads, [  --with-threads=[posix]  support threading ])
dnl GIMP_THREAD_LIBS=
dnl if test "x$with_threads" = "xposix" || test "x$with_threads" = "xyes"; then
dnl   AC_CHECK_LIB(pthread, pthread_attr_init, 
dnl     [AC_DEFINE(USE_PTHREADS)
dnl     GIMP_THREAD_LIBS="-lpthread"
dnl     GIMP_THREAD_FLAGS="-D_REENTRANT"],
dnl     # AIX has libpthreads, cause they're special. Special friends (TM)
dnl     AC_CHECK_LIB(pthreads, pthread_attr_init,
dnl       [AC_DEFINE(USE_PTHREADS)
dnl       GIMP_THREAD_LIBS="-lpthreads"
dnl       GIMP_THREAD_FLAGS="-D_REENTRANT -D_THREAD_SAFE"]))
dnl fi

dnl Multi-Processor Support
AC_ARG_WITH(mp, [  --with-mp=[no]          support multiple processors ])
GIMP_MP_LIBS=
if test "x$with_mp" = "xyes"; then
  AC_CHECK_LIB(pthread, pthread_attr_init, 
    [AC_DEFINE(ENABLE_MP)
    GIMP_MP_LIBS="-lpthread"
    GIMP_MP_FLAGS="-D_REENTRANT"],
    # AIX has libpthreads, cause they're special. Special friends (TM)
    AC_CHECK_LIB(pthreads, pthread_attr_init,
      [AC_DEFINE(ENABLE_MP)
      GIMP_MP_LIBS="-lpthreads"
      GIMP_MP_FLAGS="-D_REENTRANT -D_THREAD_SAFE"]))
fi

gimpdatadir=$datadir/$PACKAGE/$GIMP_MAJOR_VERSION.$GIMP_MINOR_VERSION
gimpplugindir=$libdir/$PACKAGE/$GIMP_MAJOR_VERSION.$GIMP_MINOR_VERSION
gimpsysconfdir=$sysconfdir/$PACKAGE/$GIMP_MAJOR_VERSION.$GIMP_MINOR_VERSION

localedir='${prefix}/${DATADIRNAME}/locale'

brushdata=`ls -1 $srcdir/data/brushes | grep -v Makefile`
gradientdata=`ls -1 $srcdir/data/gradients | grep -v Makefile`
palettedata=`ls -1 $srcdir/data/palettes | grep -v Makefile`
patterndata=`ls -1 $srcdir/data/patterns | grep -v Makefile`

brushdata=`echo $brushdata`
gradientdata=`echo $gradientdata`
palettedata=`echo $palettedata`
patterndata=`echo $patterndata`

dnl This is for generating PDB docuemntation.
AC_PATH_PROGS(EMACS, emacs xemacs, :)

dnl This is for the developers documentation.
AC_CHECK_PROG(GTKDOC, gtkdoc-mkdb, true, false)
AM_CONDITIONAL(HAVE_GTK_DOC, $GTKDOC)
AC_SUBST(HAVE_GTK_DOC)

dnl Let people disable the gtk-doc stuff.
AC_ARG_ENABLE(gtk-doc, [  --enable-gtk-doc        use gtk-doc to build documentation [default=auto]], enable_gtk_doc="$enableval", enable_gtk_doc=auto)

if test x$enable_gtk_doc = xauto ; then
  if test x$GTKDOC = xtrue ; then
    enable_gtk_doc=yes
  else
    enable_gtk_doc=no
  fi
fi

AM_CONDITIONAL(ENABLE_GTK_DOC, test x$enable_gtk_doc = xyes)

AC_ARG_WITH(html-dir, [  --with-html-dir=PATH    path to installed docs ])
if test "x$with_html_dir" = "x" ; then
  HTML_DIR='${gimpdatadir}/devel-docs/html'
else
  HTML_DIR=$with_html_dir
fi

dnl This is for the mail plug-in
AC_ARG_WITH(sendmail,[  --with-sendmail=DIR     set sendmail command location])

if test "x$with_sendmail" != "x"; then
  sendmail_path=$with_sendmail
else
  sendmail_path=$PATH:/usr/sbin:/usr/lib
fi

AC_PATH_PROG(SENDMAIL, sendmail, , $sendmail_path)
if test "x$SENDMAIL" != "x"; then
  AC_DEFINE_UNQUOTED(SENDMAIL, "$SENDMAIL",
	             [The MTA used by the mail plug-in.])
fi


dnl This is for the print plug-in
GIMPPRINT_REQUIRED_VERSION=4.2.0
AC_ARG_ENABLE(print, [  --disable-print         build without print support (requires libgimpprint)])
  if test "x$enable_print" != "xno"; then
  AC_PATH_PROG(PRINT_CONFIG, gimpprint-config, no)
    if test "x$PRINT_CONFIG" != "xno"; then
      AC_MSG_CHECKING(for gimpprint >= $GIMPPRINT_REQUIRED_VERSION)
      print_version=`$PRINT_CONFIG --version`
      if expr $print_version \>= $GIMPPRINT_REQUIRED_VERSION >/dev/null; then
        AC_MSG_RESULT([yes (version $print_version)])
        PRINT=print
        PRINT_LIBS=`$PRINT_CONFIG --libs`
        PRINT_CFLAGS=`$PRINT_CONFIG --cflags`
      else
        AC_MSG_WARN([
*** libgimpprint version $print_version is too old.
*** You need at least version $GIMPPRINT_REQUIRED_VERSION.])
      fi
    fi
  fi

if test x$enable_print != xno && test -z "$PRINT"; then
  AC_MSG_ERROR([
*** Check for libgimpprint failed. You can download it from 
*** http://gimp-print.sourceforge.net/ or you can build without it by passing 
*** --disable-print to configure (but you won't be able to print then).])
fi


dnl This is for the gimp-perl plug-in
AC_ARG_ENABLE(perl, [  --disable-perl          do not build perl extension [by default enabled]
  --enable-perl[=prefix]  use specified prefix for perl (see INSTALL)])

AC_ARG_WITH(pdbgen, [  --with-pdbgen           use 'pdbgen' code generation tool],
,
with_pdbgen=$enable_maintainer_mode)

if test "x$enable_perl" != xno || test "x$with_pdbgen" = xyes ; then
   AC_PATH_PROGS(PERL,perl5 perl perl5.005 perl5.004,perl)
fi

AM_CONDITIONAL(WITH_PDBGEN, test x$with_pdbgen = xyes)
AM_CONDITIONAL(WITH_AUTHORSGEN, test x$enable_maintainer_mode = xyes)

rm -f plug-ins/perl/config.status

if test "x$enable_perl" != xno; then
   AC_MSG_CHECKING(for perl version >= 5.004_04)
   if test "`$PERL -e 'print $]>=5.004_04'`" = "1"; then
      AC_MSG_RESULT(yes)
      
      dnl perl does not allow VPATH builds (yet)
      if test ! -f plug-ins/perl/Makefile.PL; then
         mkdir plug-ins || true
         cp -r $srcdir/plug-ins/perl plug-ins/perl
      fi
      
      dnl these are gross hacks
      GIMP_CFLAGS_NOUI="-I\$topdir/../.. $GLIB_CFLAGS $GTK_CFLAGS"
      GIMP_CFLAGS="$GIMP_CFLAGS_NOUI"
      GIMP_LIBS_NOUI="-L\$topdir/../../libgimp/.libs -L\$topdir/../../libgimp -lgimp $GLIB_LIBS $LIBS"
      GIMP_LIBS="$GIMP_LIBS_NOUI -lgimpui"
      GIMPTOOL="../../gimptool-1.2"
      IN_GIMP=1
      EXTENSIVE_TESTS=0

      dnl include the autoconf fragment from there
      sinclude(plug-ins/perl/configure.frag)

      dnl we ignore prefix
      if test -n "$enable_perl" && test "x$enable_perl" != xyes; then
         perl_prefix="PREFIX=$enable_perl"
      fi
      cat >plug-ins/perl/config.status <<EOF
      echo invoking perl for configuration...
      $PERL Makefile.PL --writemakefile $perl_prefix
EOF
      GIMP_PERL=perl
      GIMP_PERL_PO=plug-ins/perl/po
   else
      GIMP_PERL=
      GIMP_PERL_PO=
      AC_MSG_RESULT(no)
      AC_MSG_WARN(*** gimp-perl plug-in won't be build (perl5.004_04 or higher required) ***)
   fi
fi

dnl Pygimp configure stuff ...
dnl AC_ARG_ENABLE(python,
dnl [  --disable-python        do not build python extension],,[enable_python=no])
dnl build_python=false
dnl if test "x$enable_python" != xno; then
dnl   AM_PATH_PYTHON
dnl   if test "x$PYTHON" != xno; then
dnl     AM_INIT_PYEXEC_MOD
dnl     if test "x$am_cv_python_makefile" != xno; then
dnl       PYGIMP_CFLAGS_NOUI="-I\$(top_srcdir) $GLIB_CFLAGS"
dnl       PYGIMP_LIBS_NOUI="-L\$(top_builddir)/libgimp/.libs -lgimp $GLIB_LIBS"
dnl 
dnl       build_python=true
dnl       AM_CHECK_PYMOD(gtk,,,build_python=false)
dnl     fi
dnl   fi
dnl fi
dnl AC_SUBST(PYGIMP_CFLAGS_NOUI)
dnl AC_SUBST(PYGIMP_LIBS_NOUI)
dnl AM_CONDITIONAL(BUILD_PYTHON, $build_python)
  

GIMPINSTALL=
if test "$INSTALL" = "$ac_install_sh"; then
  GIMPINSTALL="gimpinstall-1.2"
fi

GIMPDOCS=
if test -n "$DISTMAKE"; then
  HELPBROWSER=helpbrowser WEBBROWSER=webbrowser
  TIFF=tiff JPEG=jpeg PNG=png AA=aa MPEG=mpeg XJT=xjt XPM=xpm
  GIMPDOCS=docs
fi

dnl eek, what a hack...
rm -f confauthorsgen

IFS="${IFS=         }"; gimp_save_IFS="$IFS"; IFS='
'

for i in `sed -e '/^#/d' -e 's/\.*\[.*\]//' -e 's/^ *//' -e 's/ *$//' -e '/^$/d' < $srcdir/tools/authorsgen/contributors`; do
  echo $ac_n$ECHO_N "$i, $ac_c$ECHO_C" >> confauthorsgen
done

IFS="$gimp_save_IFS"

GIMP_CONTRIBUTORS=`sed -e 's/, $/./' < confauthorsgen`
rm -f confauthorsgen

AM_CONDITIONAL(STATICLIBS, test x$enable_static = xyes)

AC_ARG_ENABLE(debug, [  --enable-default-binary install this as the default gimp binary [default=yes]], , enable_default_binary=yes)

AM_CONDITIONAL(DEFAULT_BINARY, test x$enable_default_binary = xyes)

CPPFLAGS="${CPPFLAGS} -DGTK_DISABLE_COMPAT_H"

AC_SUBST(GIMP_MAJOR_VERSION)
AC_SUBST(GIMP_MINOR_VERSION)
AC_SUBST(GIMP_MICRO_VERSION)
AC_SUBST(GIMP_VERSION)

AC_SUBST(LT_RELEASE)
AC_SUBST(LT_CURRENT)
AC_SUBST(LT_REVISION)
AC_SUBST(LT_AGE)
AC_SUBST(LT_CURRENT_MINUS_AGE)

AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)

AC_SUBST(gimpdir)
AC_SUBST(gimpdatadir)
AC_SUBST(gimpplugindir)
AC_SUBST(gimpsysconfdir)
AC_SUBST(localedir)
AC_SUBST(brushdata)
AC_SUBST(gradientdata)
AC_SUBST(palettedata)
AC_SUBST(patterndata)
AC_SUBST(GIMP_REMOTE)	
AC_SUBST(WEBBROWSER)
AC_SUBST(LIBXMU)
AC_SUBST(TIFF)
AC_SUBST(LIBTIFF)
AC_SUBST(JPEG)
AC_SUBST(XJT)
AC_SUBST(LIBJPEG)
AC_SUBST(PSP)
AC_SUBST(LIBZ)
AC_SUBST(PNG)
AC_SUBST(LIBPNG)
AC_SUBST(AA)
AC_SUBST(LIBAA)
AC_SUBST(MPEG)
AC_SUBST(LIBMPEG)
AC_SUBST(GAP_DECODE_MPEG)
AC_SUBST(XPM)
AC_SUBST(LIBXPM)
AC_SUBST(LIBUCB)
AC_SUBST(PRINT)
AC_SUBST(PRINT_LIBS)
AC_SUBST(PRINT_CFLAGS)
AC_SUBST(GIMP_THREAD_FLAGS)
AC_SUBST(GIMP_THREAD_LIBS)
AC_SUBST(GIMP_MP_FLAGS)
AC_SUBST(GIMP_MP_LIBS)
AC_SUBST(GIMP_PERL)
AC_SUBST(GIMP_PERL_PO)	
AC_SUBST(GIMPDOCS)
AC_SUBST(GIMPINSTALL)
AC_SUBST(HELPBROWSER)
AC_SUBST(GTKXMHTML_CFLAGS)
AC_SUBST(GTKXMHTML_LIBS)
AC_SUBST(HTML_DIR)

AC_SUBST(GIMP_CONTRIBUTORS)

dnl easy way to skip the plug-in build
GIMP_PLUGINS=plug-ins
GIMP_MODULES=modules
AC_SUBST(GIMP_PLUGINS)
AC_SUBST(GIMP_MODULES)

dnl Output the Makefiles

AC_OUTPUT([
gimp-1.2.1
gimprc
gimprc_user
gimprc-1.2.5
gimptool-1.2
gimptool-1.2.1
gimp-remote-1.2.1
gimp.spec
gimp-zip
gimptool-win32.c
libgimp/gimpfeatures.h
libgimp/Makefile
libgimp/makefile.mingw
app/Makefile
app/makefile.mingw
app/gimp.rc
plug-ins/Makefile
plug-ins/makefile.mingw
plug-ins/perl/config.pl
plug-ins/libgck/Makefile
plug-ins/libgck/gck/Makefile
plug-ins/dbbrowser/Makefile
plug-ins/script-fu/Makefile
plug-ins/script-fu/scripts/Makefile
plug-ins/webbrowser/Makefile
plug-ins/xjt/Makefile
plug-ins/FractalExplorer/Makefile
plug-ins/FractalExplorer/fractalexplorer-examples/Makefile
plug-ins/Lighting/Makefile
plug-ins/MapObject/Makefile
plug-ins/bmp/Makefile
plug-ins/common/Makefile
plug-ins/faxg3/Makefile
plug-ins/fits/Makefile
plug-ins/flame/Makefile
plug-ins/fp/Makefile
plug-ins/gap/Makefile
plug-ins/gdyntext/Makefile
plug-ins/gfig/Makefile
plug-ins/gfig/gfig-examples/Makefile
plug-ins/gflare/Makefile
plug-ins/gflare/gflares/Makefile
plug-ins/gfli/Makefile
plug-ins/gimpressionist/Makefile
plug-ins/gimpressionist/Brushes/Makefile
plug-ins/gimpressionist/Paper/Makefile
plug-ins/gimpressionist/Presets/Makefile
plug-ins/helpbrowser/Makefile
plug-ins/ifscompose/Makefile
plug-ins/imagemap/Makefile
plug-ins/maze/Makefile
plug-ins/mosaic/Makefile
plug-ins/pagecurl/Makefile
plug-ins/print/Makefile
plug-ins/rcm/Makefile
plug-ins/sel2path/Makefile
plug-ins/sgi/Makefile
plug-ins/twain/Makefile
plug-ins/winsnap/Makefile
modules/Makefile
modules/makefile.mingw
devel-docs/Makefile
devel-docs/libgimp/Makefile
devel-docs/pdb/Makefile
data/Makefile
data/brushes/Makefile
data/gradients/Makefile
data/palettes/Makefile
data/patterns/Makefile
Makefile
build/Makefile
build/win32/Makefile
build/win32/dirent/Makefile
po/Makefile.in
po-libgimp/Makefile.in
plug-ins/perl/po/Makefile.in
po-plug-ins/Makefile.in
po-script-fu/Makefile.in
intl/Makefile
tools/Makefile
tools/authorsgen/Makefile
tools/pdbgen/Makefile
tips/Makefile
help/Makefile
help/C/Makefile
help/C/channels/Makefile
help/C/dialogs/Makefile
help/C/dialogs/channels/Makefile
help/C/dialogs/color_selectors/Makefile
help/C/dialogs/gradient_editor/Makefile
help/C/dialogs/layers/Makefile
help/C/dialogs/palette_editor/Makefile
help/C/dialogs/paths/Makefile
help/C/dialogs/preferences/Makefile
help/C/file/Makefile
help/C/filters/Makefile
help/C/image/Makefile
help/C/image/edit/Makefile
help/C/image/image/Makefile
help/C/image/image/colors/Makefile
help/C/image/image/colors/auto/Makefile
help/C/image/image/mode/Makefile
help/C/image/image/transforms/Makefile
help/C/image/select/Makefile
help/C/image/view/Makefile
help/C/images/Makefile
help/C/images/examples/Makefile
help/C/images/glossary/Makefile
help/C/images/tools/Makefile
help/C/layers/Makefile
help/C/layers/stack/Makefile
help/C/open/Makefile
help/C/paths/Makefile
help/C/save/Makefile
help/C/stylesheet-images/Makefile
help/C/toolbox/Makefile
help/C/toolbox/help/Makefile
help/C/tools/Makefile],
[
   chmod +x gimptool-1.2
   sed -e "s/^     ..\/..\/..\//     ..\//" plug-ins/perl/po/Makefile > plug-ins/perl/po/Makefile.eek && mv plug-ins/perl/po/Makefile.eek plug-ins/perl/po/Makefile
   case "$CONFIG_FILES" in
   *plug-ins/perl*)
      if test -f plug-ins/perl/config.status; then
         ( cd plug-ins/perl; ${CONFIG_SHELL-/bin/sh} config.status )
      fi
      ;;
   esac
]
)
